package com.liveneo.adapter.mobile.util;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;

/**
 * 功能：对日期操作的公共方法类 作者：袁伟民 时间：2009-7-29 21:16 修改：
 * 
 */
public class DateUtil {

    /***
     * 格式化日期的方法
     * 
     * @param date
     * 带格式化的日期
     * @param pattern
     * 格式化的表达式 比如 yyyy-MM-dd
     * @return 格式化后的字符串
     */
    public static String formatDate(Date date, String pattern) {
        // 建立日期FORMAT的实例
        SimpleDateFormat df = new SimpleDateFormat(pattern);
        return df.format(date);
    }

    /***
     * 格式化日期的方法
     * 
     * @param date
     * 带格式化的日期，默认为yyyy-MM-dd
     * @return 格式化后的字符串
     */
    public static String formatDate(Date date) {
        return formatDate(date, "yyyy-MM-dd");
    }

    /**
     * 利用传入的日期，返回上一个月当天的日期对象
     * 
     * @param current
     * ：当前日期对象
     * @return 上一个月的当天的日期对象
     */
    public static Date getPreviousMonth(Date current) {
        if (current.getMonth() != 1) {
            // 如果不是一月份，则直接减去一天
            return new Date(current.getYear(), current.getMonth() - 1, current.getDate());
        } else {
            // 如果是一月份，则需要在年上减去一天，月变为12
            return new Date(current.getYear() - 1, 12, current.getDate());
        }
    }

    /**
     * 利用传入的日期，返回上一个月当天的日期对象
     * 
     * @param current
     * ：当前日期对象
     * @return 上一个月的当天的日期对象
     */
    public static Date getNextMonth(Date current) {
        if (current.getMonth() != 12) {
            // 如果不是一月份，则直接减去一天
            return new Date(current.getYear(), current.getMonth() + 1, current.getDate());
        } else {
            // 如果是一月份，则需要在年上减去一天，月变为12
            return new Date(current.getYear() + 1, 0, current.getDate());
        }
    }

    /**
     * 利用传入的日期,返回下个月最后一天的日期
     * guoyonggang
     * 
     * @return
     */
    public static Date getNextMonthEnd(Date current) {
        Calendar lastDate = Calendar.getInstance();
        lastDate.setTime(current);
        lastDate.add(Calendar.MONTH, 1);// 加一个月
        lastDate.set(Calendar.DATE, 1);// 把日期设置为当月第一天
        lastDate.roll(Calendar.DATE, -1);// 日期回滚一天，也就是本月最后一天
        Date date = lastDate.getTime();
        return date;
    }

    /** 利用传入日期，返回一个上个月日期的yyyyMM的String表达式 */
    public static String getPreviousMonths(Date current) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
        return sdf.format(getPreviousMonth(current));
    }

    /***
     * 获取传入日期上一年的日期对象
     * 
     * @param date
     * 传入的日期对象
     * @return 上一年的日期对象
     */
    public static Date getPreviousYear(Date date) {
        return new Date(date.getYear() - 1, date.getMonth(), date.getDate());
    }

    public static Date getThreeDaysAgo(Date date) {
        return new Date(date.getYear(), date.getMonth(), date.getDate() - 3);
    }

    /***
     * 获取传入日期下一年的日期对象
     * 
     * @param date
     * 传入的日期对象
     * @return 下一年的日期对象
     */
    public static Date getNextYear(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.YEAR, 1);
        return calendar.getTime();
        // return new Date(date.getYear() + 1, date.getMonth(), date.getDate());
    }

    /***
     * 获取传入日期下n年的日期对象
     * 
     * @param date
     * 传入的日期对象
     * @return 下n年的日期对象
     */
    public static Date getNextNYear(Date date, int n) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.YEAR, n);
        return calendar.getTime();
        // return new Date(date.getYear() + n, date.getMonth(), date.getDate());
    }

    /***
     * 计算传入日期的往后顺延N天以后的日期对象
     * 
     * @param date
     * 传入的日期对象
     * @param n
     * 往后顺延的天数
     * @return 顺延后的日期对象
     */
    public static Date getPreviousNDate(Date date, long n) {
        long time = date.getTime();
        // 用毫秒数来计算新的日期
        time = time - n * 24 * 60 * 60 * 1000;
        return new Date(time);
    }

    /***
     * 计算传入日期的往前推算N天的日期对象
     * 
     * @param date
     * 传入的日期对象
     * @param n
     * 往后顺延的天数
     * @return 往前推算后的日期对象
     */
    public static Date getNextNDate(Date date, long n) {
        long time = date.getTime();
        // 用毫秒数来计算新的日期
        time = time + n * 24 * 60 * 60 * 1000;
        return new Date(time);
    }

    /***
     * 计算传入日期的前一天
     * 
     * @param date
     * 传入日期
     * @return 传入日期的前一天的日期对象
     */
    public static Date getPreviousDate(Date date) {
        return getPreviousNDate(date, 1);
    }

    /***
     * 计算传入日期的后一天
     * 
     * @param date
     * 传入日期
     * @return 传入日期的后一天的日期对象
     */
    public static Date getNextDate(Date date) {
        return getNextNDate(date, 1);
    }

    /**
     * 日期转换成字符串
     * 
     * @作者：滑立敏
     * @日期：2010-01-26
     * @param date
     * @return str
     */
    public static String dateToMonthStr(Date date) {

        if (date == null) return null;

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
        String str = format.format(date);
        return str;
    }

    /**
     * 日期转换成字符串
     * 
     * @作者：滑立敏
     * @日期：2010-01-26
     * @param date
     * @return str
     */
    public static String dateToStr(Date date) {

        if (date == null) return null;

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String str = format.format(date);
        return str;
    }

    /**
     * 日期转换成字符串（精确到秒）
     * 
     * @作者：滑立敏
     * @日期：2010-01-26
     * @param date
     * @return str
     */
    public static String dateToStrs(Date date) {

        if (date == null) return null;

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str = format.format(date);
        return str;
    }

    /**
     * 日期转换成字符串
     * 
     * @作者：滑立敏
     * @日期：2013-01-16
     * @param date
     * @return str
     */
    public static String date24ToStr(Date date) {

        if (date == null || "".equals(date)) return "";

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str = format.format(date);
        return str;
    }

    /**
     * 字符串转换成日期
     * 
     * @作者：滑立敏
     * @日期：2010-01-26
     * @param str
     * @return date
     */
    public static Date strToDate(String str) {

        if (str == null || "".equals(str)) return null;

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = format.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 字符串转换成日期
     * 
     * @作者：滑立敏
     * @日期：2010-01-26
     * @param str
     * @return date
     */
    public static Date strToDateYYYYMM(String str) {

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
        Date date = null;
        try {
            date = format.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 获取当月多少天
     * 
     * @param date
     * @return
     */
    public static int getMonth(Date date) {
        String month = new SimpleDateFormat("MM").format(date);
        return Integer.parseInt(month);
    }

    /**
     * 获取当月多少天
     * 
     * @param date
     * @return
     */
    public static int getYear(Date date) {
        String month = new SimpleDateFormat("yyyy").format(date);
        return Integer.parseInt(month);
    }

    /**
     * 字符串转换成日期
     * 
     * @作者：滑立敏
     * @日期：2010-01-26
     * @param str
     * @return date
     */
    public static Date strToDate24(String str) {

        if (str == null || "".equals(str)) return null;

        Date date = null;
        if (str.contains(":")) {
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

            try {
                date = format.parse(str);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        } else {
            date = strToDate(str);
        }
        return date;
    }

    /**
     * 根据传入的日期计算此日期与下一年该日相差的天数
     * 
     * @param startDate
     * 起始日期
     * @return 天数区间
     * 
     * @作者：李阳
     * @时间：2010-06-22
     */
    public static int getDaysCountForYear(Date startDate) {
        // 获取传入日期下一年的日期对象
        Date nextYear = getNextYear(startDate);
        // 计算天数
        return getDaysCount(startDate, nextYear);
    }

    /***
     * 根据起始日期、终止日期计算天数
     * 
     * @param startDate
     * 起始日期
     * @param endDate
     * 终止日期
     * @return 天数区间
     */
    public static int getDaysCount(Date startDate, Date endDate) {
        return getDaysCount(startDate, 0, endDate, 0);
    }

    /***
     * 根据年数返回所包含的天数
     * 
     * @param year
     * 年数
     * @return 该年所包含的天数
     */
    public static int getDaysFromYear(int year) {
        // 判断是平年还是闰年
        if ((year % 400 == 0) || (year % 100 != 0) && (year % 4 == 0)) {
            return 366;
        } else
            return 365;

    }

    /***
     * 根据起始日期、起始时间、终止日期、终止时间计算天数
     * 
     * @param startDate
     * 起始日期
     * @param startHour
     * 起始小时
     * @param endDate
     * 终止日期
     * @param endHour
     * 终止小时
     * @return 天数区间
     */
    public static int getDaysCount(Date startDate, int startHour, Date endDate, int endHour) {
        // 根据起始日期计算起始的毫秒
        long startTime = startDate.getTime();
        // 根据终止日期计算终止的毫秒
        long endTime = endDate.getTime();
        // 通过起始毫秒和终止毫秒的差值，计算天数
        int dayCount = (int) ((endTime - startTime) / (24 * 60 * 60 * 1000) + 1);

        if (endHour <= startHour) {
            if (startHour == 24 && endHour == 0) {
                dayCount = dayCount - 2;
            } else {
                dayCount = dayCount - 1;
            }
        }
        return dayCount;

    }

    /***
     * 根据起始日期、终止日期计算月数
     * 
     * @param startDate
     * 起始日期
     * @param endDate
     * 终止日期
     * @return 天数区间
     */
    public static int getMonthsCount(Date startDate, Date endDate) {
        return getMonthsCount(startDate, 0, endDate, 0);
    }

    /***
     * 根据起始日期、起始时间、终止日期、终止时间计算天数
     * 
     * @param startDate
     * 起始日期
     * @param startHour
     * 起始小时
     * @param endDate
     * 终止日期
     * @param endHour
     * 终止小时
     * @return 天数区间
     */
    public static int getMonthsCount(Date startDate, int startHour, Date endDate, int endHour) {
        // 年份差
        int yearDiff = endDate.getYear() - startDate.getYear();
        // 月份差
        int monthDiff = endDate.getMonth() - startDate.getMonth();
        // 总的月数量
        int monthCount = monthDiff + yearDiff * 12;
        // 天数差
        long dayDiff = endDate.getDate() - startDate.getDate();
        // 不足一个月按一个月计算
        if (dayDiff > 0 || (dayDiff == 0 && endHour > startHour)) {
            monthCount = monthCount + 1;
        }

        return monthCount;

    }

    /***
     * 根据起始日期、终止日期计算年数
     * 
     * @param startDate
     * 起始日期
     * @param endDate
     * 终止日期
     * @return 天数区间
     */
    public static int getYearsCount(Date startDate, Date endDate) {
        return getYearsCount(startDate, 0, endDate, 0);
    }

    /***
     * 根据起始日期、起始时间、终止日期、终止时间计算天数
     * 
     * @param startDate
     * 起始日期
     * @param startHour
     * 起始小时
     * @param endDate
     * 终止日期
     * @param endHour
     * 终止小时
     * @return 天数区间
     */
    public static int getYearsCount(Date startDate, int startHour, Date endDate, int endHour) {
        int yearCount = 0;

        // 获取之间的月数
        int monthCount = getMonthsCount(startDate, startHour, endDate, endHour);

        yearCount = monthCount / 12;

        if (monthCount % 12 != 0) {
            yearCount++;
        }

        // 返回年数
        return yearCount;
    }

    /**
     * 根据日期获取总小时数
     * 
     * @param date
     * 日期对象
     * @return 总小时数
     */
    public static int getHoursCount(Date date) {
        return getHoursCount(date, 0);
    }

    /**
     * 根据日期和小时数，获取总小时数
     * 
     * @param date
     * 日期对象
     * @param hour
     * 小时数
     * @return 总小时数
     */
    public static int getHoursCount(Date date, Integer hour) {
        long hourCount = hour;
        hourCount += date.getTime() / 3600 / 1000;
        return (int) hourCount;
    }

    /***
     * 比较两个日期的大小
     * 
     * @param startDate
     * 开始日期
     * @param endDate
     * 结束日期
     * @return -1 ： 开始日期小于结束日期 0 ： 开始日期等于结束日期 1 ： 开始日期大于结束日期
     */
    public static int compareDate(Date startDate, Date endDate) {
        long startTime = startDate.getTime();
        long endTime = endDate.getTime();
        if (startTime < endTime) {
            return -1;
        }
        if (startTime == endTime) {
            return 0;
        }
        return 1;
    }

    /***
     * 比较两个日期的大小
     * 
     * @param startDate
     * 开始日期
     * @param endDate
     * 结束日期
     * @return -1 ： 开始日期小于结束日期 0 ： 开始日期等于结束日期 1 ： 开始日期大于结束日期
     */
    public static int compareDate(String startDate, String endDate) {
        return compareDate(strToDate(startDate), strToDate(endDate));
    }

    /***
     * 根据起始日期、起始时间、终止日期、终止时间计算月数，计算的是去掉多余天数的月数
     * 
     * 作者：刘立伟 时间：2010-10-20
     * 
     * @param startDate
     * 起始日期
     * @param startHour
     * 起始小时
     * @param endDate
     * 终止日期
     * @param endHour
     * 终止小时
     * @return 期间相差的月数(去掉多余的天数)
     */
    public static int getMinMonthsCount(Date startDate, int startHour, Date endDate, int endHour) {
        // 年份差
        int yearDiff = endDate.getYear() - startDate.getYear();
        // 月份差
        int monthDiff = endDate.getMonth() - startDate.getMonth();
        // 总的月数量
        int monthCount = monthDiff + yearDiff * 12;
        // 天数差
        long dayDiff = endDate.getDate() - startDate.getDate();
        if (startHour == 0 && endHour == 24) {
            dayDiff += 1;
        }
        // 如果天数差小于0或者天数差等于零（并且终止小时小于起始小时），那么月数减一。
        if (dayDiff < 0 || (dayDiff == 0 && endHour < startHour)) {
            monthCount = monthCount - 1;
        }
        return monthCount;

    }

    /***
     * 根据起始日期、起始时间、终止日期、终止时间计算天数，计算的是相差月后余下的天数
     * 
     * @param startDate
     * 起始日期
     * @param startHour
     * 起始小时
     * @param endDate
     * 终止日期
     * @param endHour
     * 终止小时
     * @return 余下的天数
     * 
     * 作者：刘立伟 时间：2010-10-20
     */
    public static int getOtherDayCount(Date startDate, int startHour, Date endDate, int endHour) {
        // 相差的天数
        int dayCount = 0;
        // 时间变量
        long newStartTime = 0;
        // 终保日期getTime变量
        long endTime = 0;
        // 计算日相差
        int dayDiff = endDate.getDate() - startDate.getDate();
        // 如果日相差等于0，那endHour > startHour,那么返回一天，如：2010-10-10：02到2010-10-10:09
        if (dayDiff == 0) {
            if (endHour > startHour) {
                return 1;
            }
            // 如果日相差小于0
        } else if (dayDiff < 0) {
            // 如果startHour < endHour，如：2010-09-18:02------2010-10-10:08
            if (startHour < endHour) {
                Date newStartDate = new Date(endDate.getYear(), endDate.getMonth() - 1, startDate.getDate());
                newStartTime = newStartDate.getTime();
                endTime = endDate.getTime();
                dayCount = (int) ((endTime - newStartTime) / (24 * 60 * 60 * 1000) + 1);
                // 如果startHour = endHour，如：2010-09-18:02------2010-10-10:02
            } else if (startHour == endHour) {
                Date newStartDate = new Date(endDate.getYear(), endDate.getMonth() - 1, startDate.getDate());
                newStartTime = newStartDate.getTime();
                endTime = endDate.getTime();
                dayCount = (int) ((endTime - newStartTime) / (24 * 60 * 60 * 1000));
                // 如果startHour > endHour
            } else if (startHour > endHour) {
                Date newStartDate = new Date(endDate.getYear(), endDate.getMonth() - 1, startDate.getDate());
                newStartTime = newStartDate.getTime();
                endTime = endDate.getTime();
                dayCount = (int) ((endTime - newStartTime) / (24 * 60 * 60 * 1000) + 1);
                // 如：2010-09-18:24------2010-10-10:00
                if (startHour == 24 && endHour == 0) {
                    dayCount = dayCount - 2;
                    // 如：2010-09-18:14------2010-10-10:10
                } else {
                    dayCount = dayCount - 1;
                }
            }
            // 日相差大于0
        } else if (dayDiff > 0) {
            // 如果startHour < endHour
            if (startHour > endHour) {
                Date newStartDate = new Date(endDate.getYear(), endDate.getMonth(), startDate.getDate());
                newStartTime = newStartDate.getTime();
                endTime = endDate.getTime();
                // 如：2010-10-10:08------2010-10-18:02
                dayCount = (int) ((endTime - newStartTime) / (24 * 60 * 60 * 1000));
                // 如：2010-10-10:24------2010-10-18:00
                if (startHour == 24 && endHour == 0) {
                    dayCount = dayCount - 1;
                }
                // 如果startHour = endHour，如：2010-10-10:08------2010-10-18:08
            } else if (startHour == endHour) {
                Date newStartDate = new Date(endDate.getYear(), endDate.getMonth(), startDate.getDate());
                newStartTime = newStartDate.getTime();
                endTime = endDate.getTime();
                dayCount = (int) ((endTime - newStartTime) / (24 * 60 * 60 * 1000));
                // 如果startHour < endHour，如：2010-10-10:02------2010-10-18:08
            } else if (startHour < endHour) {
                Date newStartDate = new Date(endDate.getYear(), endDate.getMonth(), startDate.getDate());
                newStartTime = newStartDate.getTime();
                endTime = endDate.getTime();
                dayCount = (int) ((endTime - newStartTime) / (24 * 60 * 60 * 1000) + 1);
            }
        }
        return dayCount;
    }

    public static void main(String[] args) {
        System.out.println(new Date());
        String s = DateUtil.formatDate(new Date(), "yyyy-MM-dd 00:00:00");
        System.out.println(s);
        System.out.println(DateUtil.strToDate24(s));

        Date date = getNextMonth(strToDate("2010-12-05"));
        // System.out.println(formatDate(date, "yyyy-MM-dd"));
        // System.out.println(getHoursCount(strToDate("2010-12-05")));
        // System.out.println(getHoursCount(strToDate("2010-12-06")));

        /*
         * String str = "2012-12-12 23:23:22";
         * 
         * if (str == null || "".equals(str)) return ;
         * 
         * if (str.contains(":"))
         * {
         * System.out.println("日期加时间" + strToDate24(str));
         * }else
         * {
         * System.out.println(" 日期无时间"+strToDate(str));
         * }
         */

        // Date date1 = new Date();
        //
        // String str = null;

        System.out.println(getCurrentTime());
    }

    public static String getTimeSecond() {
        String currentDate = "";
        String strMonth = "";
        String strDate = "";

        currentDate += Calendar.getInstance().get(Calendar.YEAR);
        strMonth = "" + (Calendar.getInstance().get(Calendar.MONTH) + 1);
        if (strMonth.length() == 1) {
            currentDate += "0" + strMonth;
        } else {
            currentDate += strMonth;
        }
        strDate = "" + Calendar.getInstance().get(Calendar.DATE);
        if (strDate.length() == 1) {
            currentDate += "0" + strDate;
        } else {
            currentDate += strDate;
        }
        String strHour = "" + Calendar.getInstance().get(Calendar.HOUR_OF_DAY);
        if (strHour.length() == 1) {
            currentDate += "0" + strHour;
        } else {
            currentDate += strHour;
        }
        String strMinute = "" + Calendar.getInstance().get(Calendar.MINUTE);
        if (strMinute.length() == 1) {
            currentDate += "0" + strMinute;
        } else {
            currentDate += strMinute;
        }
        String strSecond = "" + Calendar.getInstance().get(Calendar.SECOND);
        if (strSecond.length() == 1) {
            currentDate += "0" + strSecond;
        } else {
            currentDate += strSecond;
        }
        return currentDate;
    }

    /**
     * 获取当前时间
     * 
     * @return
     */
    public static Date getCurrentTime() {
        Date date = new Date();

        return date;
    }

    /**
     * 获取今年
     * 
     * @return
     */
    public static String getYear() {

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy");
        java.util.Date cur_date = new java.util.Date();
        return dateFormat.format(cur_date);
    }

    /**
     * XMLGregorianCalendar 转换为Date
     * 
     * @param cal
     * @return
     */
    public static Date convertToDate(XMLGregorianCalendar cal) {

        if (cal == null) {
            return null;
        } else {
            GregorianCalendar ca = cal.toGregorianCalendar();
            return ca.getTime();
        }

    }

    /**
     * Date 转换为 XMLGregorianCalendar
     * 
     * @param date
     * @return date2
     * @throws DatatypeConfigurationException
     */
    public static XMLGregorianCalendar dateToXMLGregorianCalendar(Date date) throws DatatypeConfigurationException {

        if (date == null) {
            return null;
        } else {
            GregorianCalendar c = new GregorianCalendar();
            c.setTime(date);
            XMLGregorianCalendar date2 = DatatypeFactory.newInstance().newXMLGregorianCalendar(c);
            return date2;
        }

    }

    /**
     * @Description:计算两个日期相差天、小时、分
     * @param endDate
     * @param beginDate
     * @return
     * @ReturnType:String
     * @exception
     * @Since:2015-8-19 下午7:12:18
     * @Author:songjin
     */
    public static String dayByDay(Date endDate, Date beginDate) {
        long l = endDate.getTime() - beginDate.getTime();
        long day = l / 86400000L;
        long hour = l / 3600000L - day * 24L;
        long min = l / 60000L - day * 24L * 60L - hour * 60L;

        String timeDiff = day + "天" + hour + "小时" + min + "分";
        return timeDiff;
    }

    /**
     * 计算两个日期相差秒数
     * 
     * @param date
     * @return date2
     * @throws DatatypeConfigurationException
     */
    public static int DvalueSeconds(Date endDate, Date startDate) {
        long endSecond = endDate.getTime();
        long startSecond = startDate.getTime();
        int timeDiff = (int) ((endSecond - startSecond) / 1000);

        return timeDiff;

    }

    public static Date getPreviousNMinutes(Date date, long n) {
        long time = date.getTime();
        // 用毫秒数来计算新的日期
        time = time - n * 60 * 1000;
        return new Date(time);
    }

    /** 利用传入日期，返回一个上个月日期的yyyyMM的String表达式 */
    public static String getDateToStr(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
        return sdf.format(date);
    }

    /**
     * 据传入的第二个参数返回传入日期xxx月（之前或之后）的第一天
     * 
     * @param date null=currentDate
     * @param param 增量 -1,上个月;0,当月;1,下个月（如此类推）
     * @return string（yyyy-MM-dd）
     */
    public static String getDateFirstDayByParam(Date date, int param) {
        Calendar calendar = Calendar.getInstance();
        if (date != null) {
            calendar.setTime(date);
        }
        calendar.add(Calendar.MONTH, param);
        int lastDay = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);
        Date lastDate = calendar.getTime();
        lastDate.setDate(lastDay);
        return formatDate(lastDate);
    }

    /**
     * 返回传入日期上个月的最后一天
     * 
     * @param date null=currentDate
     * @param param 增量-1,上个月;0,当月;1,下个月（如此类推）
     * @return string（yyyy-MM-dd）
     */
    public static String getDateLastDayByParam(Date date, int param) {
        Calendar calendar = Calendar.getInstance();
        if (date != null) {
            calendar.setTime(date);
        }
        calendar.add(Calendar.MONTH, param);
        int lastDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        Date lastDate = calendar.getTime();
        lastDate.setDate(lastDay);
        return formatDate(lastDate);
    }
}
